to round off

SARRERA DESBERDINA:

Round-off error

Then ${\displaystyle fl(9.4)=9.4-0.4\times 2^{-48}+2^{-49}=9.4+(0.2)_{10}\times 2^{-49}}$.
Thus, the roundoff error is ${\displaystyle (0.2\times 2^{-49})_{10}}$.

In computing, a roundoff error,^[1] also called rounding error,^[2] is the difference between the result produced by a given algorithm using exact arithmetic and the result produced by the same algorithm using finite-precision, rounded arithmetic.^[3] Rounding errors are due to inexactness in the representation of real numbers and the arithmetic operations done with them. This is a form of quantization error.^[4] When using approximation equations or algorithms, especially when using finitely many digits to represent real numbers (which in theory have infinitely many digits), one of the goals of numerical analysis is to estimate computation errors.^[5] Computation errors, also called numerical errors, include both truncation errors and roundoff errors.
When a sequence of calculations with an input involving any roundoff error are made, errors may accumulate, sometimes dominating the calculation. In ill-conditioned problems, significant error may accumulate.^[6]
In short, there are two major facets of roundoff errors involved in numerical calculations:^[7]
The error introduced by attempting to represent a number using a finite string of digits is a form of roundoff error called representation error.^[8] Here are some examples of representation error in decimal representations:
Increasing the number of digits allowed in a representation reduces the magnitude of possible roundoff errors, but any representation limited to finitely many digits will still cause some degree of roundoff error for uncountably many real numbers. Additional digits used for intermediary steps of a calculation are known as guard digits.^[9]
Rounding multiple times can cause error to accumulate.^[10] For example, if 9.945309 is rounded to two decimal places (9.95), then rounded again to one decimal place (10.0), the total error is 0.054691. Rounding 9.945309 to one decimal place (9.9) in a single step introduces less error (0.045309). This can occur, for example, when software performs arithmetic in x86 80-bit floating-point and then rounds the result to IEEE 754 binary64 floating-point.
Compared with the fixed-point number system, the floating-point number system is more efficient in representing real numbers so it is widely used in modern computers. While the real numbers ${\displaystyle \mathbb {R} }$ are infinite and continuous, a floating-point number system ${\displaystyle F}$ is finite and discrete. Thus, representation error, which leads to roundoff error, occurs under the floating-point number system.
A floating-point number system ${\displaystyle F}$ is characterized by ${\displaystyle 4}$ integers:
Any ${\displaystyle x\in F}$ has the following form: $${\displaystyle x=\pm (\underbrace {d_{0}.d_{1}d_{2}\ldots d_{p-1}} _{\text{significand}})_{\beta }\times \beta ^{\overbrace {E} ^{\text{exponent}}}=\pm d_{0}\times \beta ^{E}+d_{1}\times \beta ^{E-1}+\ldots +d_{p-1}\times \beta ^{E-(p-1)}}$$ where ${\displaystyle d_{i}}$ is an integer such that ${\displaystyle 0\leq d_{i}\leq \beta -1}$ for ${\displaystyle i=0,1,\ldots ,p-1}$, and ${\displaystyle E}$ is an integer such that ${\displaystyle L\leq E\leq U}$.
In the IEEE standard the base is binary, i.e. ${\displaystyle \beta =2}$, and normalization is used. The IEEE standard stores the sign, exponent, and significand in separate fields of a floating point word, each of which has a fixed width (number of bits). The two most commonly used levels of precision for floating-point numbers are single precision and double precision.
Machine epsilon can be used to measure the level of roundoff error in the floating-point number system. Here are two different definitions.^[3]
There are two common rounding rules, round-by-chop and round-to-nearest. The IEEE standard uses round-to-nearest.
Suppose the usage of round-to-nearest and IEEE double precision.
Since the 53rd bit to the right of the binary point is a 1 and is followed by other nonzero bits, the round-to-nearest rule requires rounding up, that is, add 1 bit to the 52nd bit. Thus, the normalized floating-point representation in IEEE standard of 9.4 is $${\displaystyle fl(9.4)=1.0010110011001100110011001100110011001100110011001101\times 2^{3}.}$$
This representation is derived by discarding the infinite tail $${\displaystyle 0.{\overline {1100}}\times 2^{-52}\times 2^{3}=0.{\overline {0110}}\times 2^{-51}\times 2^{3}=0.4\times 2^{-48}}$$ from the right tail and then added ${\displaystyle 1\times 2^{-52}\times 2^{3}=2^{-49}}$ in the rounding step.

The machine epsilon ${\displaystyle \epsilon _{\text{mach}}}$ can be used to measure the level of roundoff error when using the two rounding rules above. Below are the formulas and corresponding proof.^[3] The first definition of machine epsilon is used here.
Let ${\displaystyle x=d_{0}.d_{1}d_{2}\ldots d_{p-1}d_{p}\ldots \times \beta ^{n}\in \mathbb {R} }$ where ${\displaystyle n\in [L,U]}$, and let ${\displaystyle fl(x)}$ be the floating-point representation of ${\displaystyle x}$. Since round-by-chop is being used, it is $${\displaystyle {\begin{aligned}{\frac {|x-fl(x)|}{|x|}}&={\frac {|d_{0}.d_{1}d_{2}\ldots d_{p-1}d_{p}d_{p+1}\ldots \times \beta ^{n}-d_{0}.d_{1}d_{2}\ldots d_{p-1}\times \beta ^{n}|}{|d_{0}.d_{1}d_{2}\ldots \times \beta ^{n}|}}\\&={\frac {|d_{p}.d_{p+1}\ldots \times \beta ^{n-p}|}{|d_{0}.d_{1}d_{2}\ldots \times \beta ^{n}|}}\\&={\frac {|d_{p}.d_{p+1}d_{p+2}\ldots |}{|d_{0}.d_{1}d_{2}\ldots |}}\times \beta ^{-p}\end{aligned}}}$$ In order to determine the maximum of this quantity, there is a need to find the maximum of the numerator and the minimum of the denominator. Since ${\displaystyle d_{0}\neq 0}$ (normalized system), the minimum value of the denominator is ${\displaystyle 1}$. The numerator is bounded above by ${\displaystyle (\beta -1).(\beta -1){\overline {(\beta -1)}}=\beta }$. Thus, ${\displaystyle {\frac {|x-fl(x)|}{|x|}}\leq {\frac {\beta }{1}}\times \beta ^{-p}=\beta ^{1-p}}$. Therefore, ${\displaystyle \epsilon =\beta ^{1-p}}$ for round-by-chop. The proof for round-to-nearest is similar.
Even if some numbers can be represented exactly by floating-point numbers and such numbers are called machine numbers, performing floating-point arithmetic may lead to roundoff error in the final result.
Machine addition consists of lining up the decimal points of the two numbers to be added, adding them, and then storing the result again as a floating-point number. The addition itself can be done in higher precision but the result must be rounded back to the specified precision, which may lead to roundoff error.^[3]
This example shows that roundoff error can be introduced when adding a large number and a small number. The shifting of the decimal points in the significands to make the exponents match causes the loss of some of the less significant digits. The loss of precision may be described as absorption.^[11]
Note that the addition of two floating-point numbers can produce roundoff error when their sum is an order of magnitude greater than that of the larger of the two.
This kind of error can occur alongside an absorption error in a single operation.
In general, the product of two p-digit significands contains up to 2p digits, so the result might not fit in the significand.^[3] Thus roundoff error will be involved in the result.
In general, the quotient of 2p-digit significands may contain more than p-digits.Thus roundoff error will be involved in the result.
Absorption also applies to subtraction.
The subtracting of two nearly equal numbers is called subtractive cancellation.^[3] When the leading digits are cancelled, the result may be too small to be represented exactly and it will just be represented as ${\displaystyle 0}$.
Even with a somewhat larger ${\displaystyle \epsilon }$, the result is still significantly unreliable in typical cases. There is not much faith in the accuracy of the value because the most uncertainty in any floating-point number is the digits on the far right.
This is closely related to the phenomenon of catastrophic cancellation, in which the two numbers are known to be approximations.
Errors can be magnified or accumulated when a sequence of calculations is applied on an initial input with roundoff error due to inexact representation.
An algorithm or numerical process is called stable if small changes in the input only produce small changes in the output, and unstable if large changes in the output are produced.^[12] For example, the computation of ${\displaystyle f(x)={\sqrt {1+x}}-1}$ using the "obvious" method is unstable near ${\displaystyle x=0}$ due to the large error introduced in subtracting two similar quantities, whereas the equivalent expression ${\displaystyle \textstyle {f(x)={\frac {x}{{\sqrt {1+x}}+1}}}}$ is stable.^[12]
Even if a stable algorithm is used, the solution to a problem may still be inaccurate due to the accumulation of roundoff error when the problem itself is ill-conditioned.
The condition number of a problem is the ratio of the relative change in the solution to the relative change in the input.^[3] A problem is well-conditioned if small relative changes in input result in small relative changes in the solution. Otherwise, the problem is ill-conditioned.^[3] In other words, a problem is ill-conditioned if its conditions number is "much larger" than 1.
The condition number is introduced as a measure of the roundoff errors that can result when solving ill-conditioned problems.^[7]
The ability of computers to represent both magnitude and precision of numbers is inherently limited.
Certain numerical manipulations are highly sensitive to roundoff errors. This can result from both mathematical considerations as well as from the way in which computers perform arithmetic operations.
Round-by-chop: ${\displaystyle \epsilon _{\text{mach}}=\beta ^{1-p}}$
Round-to-nearest: ${\displaystyle \epsilon _{\text{mach}}={\frac {1}{2}}\beta ^{1-p}}$